Premium Content

KOTLIN BASICS

Learn the fundamental structure of Kotlin programs

Beginner

Module 1: Kotlin Program Structure

Kotlin is a modern, statically-typed programming language that runs on the Java Virtual Machine (JVM). It's concise, safe, and interoperable with Java. Every Kotlin program has a basic structure that the compiler uses to execute code correctly.

Try It Yourself:

Kotlin

// Kotlin Hello World Program
fun main() {
    println("Hello, World!")
    println("Welcome to Kotlin programming!")
    
    // Basic arithmetic operations
    val x = 10
    val y = 5
    println("$x + $y = ${x + y}")
    println("$x - $y = ${x - y}")
    
    // String interpolation
    val name = "SkillMynte"
    println("Learning with $name is fun!")
}

Code Output

Key Points:

fun main() is the entry point of every Kotlin program
println() prints text to the console with a new line
val declares a read-only (immutable) variable
Kotlin supports type inference - you don't always need to specify the type
String interpolation allows embedding variables directly in strings using ${}
Comments start with // for single-line or /* */ for multi-line
Kotlin code doesn't require semicolons at the end of statements

Premium Content

VARIABLES & DATA TYPES

Learn to work with variables and different data types

Beginner

Module 2: Variables and Data Types

Kotlin provides several basic data types and two types of variable declarations: val for immutable (read-only) variables and var for mutable variables. Understanding data types is crucial for writing type-safe Kotlin code.

Try It Yourself:

Kotlin

fun main() {
    // Immutable variables (val - value)
    val name = "Alice"  // Type inferred as String
    val age = 25        // Type inferred as Int
    val height = 5.7    // Type inferred as Double
    
    // Mutable variables (var - variable)
    var score = 0
    score = 10  // This is allowed
    // name = "Bob"  // This would cause an error - val cannot be reassigned
    
    // Explicit type declarations
    val message: String = "Hello, Kotlin!"
    val temperature: Double = 23.5
    val isStudent: Boolean = true
    
    // Different data types
    val byteValue: Byte = 127
    val shortValue: Short = 32767
    val intValue: Int = 2147483647
    val longValue: Long = 9223372036854775807L
    val floatValue: Float = 3.14f
    val doubleValue: Double = 3.1415926535
    val charValue: Char = 'A'
    val booleanValue: Boolean = true
    val stringValue: String = "Kotlin is awesome!"
    
    // Printing variables
    println("Name: $name")
    println("Age: $age, Height: $height")
    println("Score: $score")
    println("Message: $message")
    println("Is student: $isStudent")
}

Code Output

Key Points:

Use val for variables that won't change (immutable)
Use var for variables that can change (mutable)
Kotlin has strong type inference - the compiler often knows the type
Basic data types: Int, Double, Float, Long, Short, Byte, Char, Boolean, String
You can explicitly specify types using : Type after the variable name
Strings support interpolation with $variable or ${expression}
Kotlin doesn't have primitive types - all types are objects

Premium Content

CONTROL FLOW

Learn to control program flow with conditionals and loops

Beginner

Module 3: Control Flow Statements

Control flow statements allow your program to make decisions and repeat actions. Kotlin provides if-else expressions, when expressions (similar to switch), and various loop constructs like for and while.

Try It Yourself:

Kotlin

fun main() {
    // If-else expressions
    val number = 10
    val result = if (number > 0) {
        "Positive"
    } else if (number < 0) {
        "Negative"
    } else {
        "Zero"
    }
    println("The number is $result")
    
    // When expression (like switch in other languages)
    val day = 3
    val dayName = when (day) {
        1 -> "Monday"
        2 -> "Tuesday"
        3 -> "Wednesday"
        4 -> "Thursday"
        5 -> "Friday"
        6, 7 -> "Weekend"
        else -> "Invalid day"
    }
    println("Day $day is $dayName")
    
    // For loops
    println("Counting from 1 to 5:")
    for (i in 1..5) {
        print("$i ")
    }
    println()
    
    println("Even numbers from 2 to 10:")
    for (i in 2..10 step 2) {
        print("$i ")
    }
    println()
    
    // While loop
    var count = 5
    println("Countdown:")
    while (count > 0) {
        print("$count ")
        count--
    }
    println("Liftoff!")
    
    // Do-while loop
    var x = 1
    println("Numbers from 1 to 3:")
    do {
        print("$x ")
        x++
    } while (x <= 3)
    println()
}

Code Output

Key Points:

In Kotlin, if-else is an expression that returns a value
when is more powerful than traditional switch statements
Ranges are created with .. operator (e.g., 1..5)
Use step to skip values in a range
for loops can iterate over ranges, arrays, collections, etc.
while checks condition before execution
do-while executes at least once before checking condition
Control flow statements can be nested for complex logic

Premium Content

FUNCTIONS

Learn to create and use functions in Kotlin

Intermediate

Module 4: Functions in Kotlin

Functions are the building blocks of Kotlin programs. They allow you to organize code into reusable units. Kotlin functions can have parameters, return values, default arguments, and can be defined in various ways including as expressions.

Try It Yourself:

Kotlin

// Basic function with return type
fun greet(name: String): String {
    return "Hello, $name!"
}

// Single-expression function
fun square(x: Int): Int = x * x

// Function with default parameters
fun createMessage(name: String, age: Int = 18, city: String = "Unknown"): String {
    return "$name is $age years old and lives in $city"
}

// Function without return value (Unit return type)
fun printInfo(info: String) {
    println("Information: $info")
}

// Function with named arguments
fun calculate(a: Int, b: Int, operation: String): Int {
    return when (operation) {
        "add" -> a + b
        "subtract" -> a - b
        "multiply" -> a * b
        "divide" -> a / b
        else -> throw IllegalArgumentException("Unknown operation: $operation")
    }
}

fun main() {
    // Using basic function
    println(greet("SkillMynte"))
    
    // Using single-expression function
    println("Square of 5 is ${square(5)}")
    
    // Using function with default parameters
    println(createMessage("Alice"))
    println(createMessage("Bob", 25))
    println(createMessage("Charlie", 30, "London"))
    
    // Using function without return value
    printInfo("Kotlin functions are powerful!")
    
    // Using function with named arguments
    println("10 + 5 = ${calculate(10, 5, "add")}")
    println("10 * 5 = ${calculate(a = 10, b = 5, operation = "multiply")}")
    
    // Lambda function (anonymous function)
    val multiply = { a: Int, b: Int -> a * b }
    println("Lambda result: ${multiply(4, 7)}")
    
    // Higher-order function (function that takes another function as parameter)
    fun operateOnNumbers(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
        return operation(a, b)
    }
    
    val result = operateOnNumbers(8, 3) { x, y -> x + y }
    println("Higher-order function result: $result")
}

Code Output

Key Points:

Functions are declared with the fun keyword
Return type is specified after the parameter list with : Type
Single-expression functions use = instead of a block
Default parameters allow calling functions with fewer arguments
Named arguments make function calls more readable
Functions without explicit return type return Unit (similar to void)
Lambda functions are anonymous functions defined with {}
Higher-order functions can take functions as parameters or return them
Kotlin supports extension functions to add functionality to existing classes

Premium Content

OOP IN KOTLIN

Learn Object-Oriented Programming concepts in Kotlin

Intermediate

Module 5: Object-Oriented Programming

Kotlin is a fully object-oriented language that supports classes, objects, inheritance, interfaces, and other OOP concepts. It improves upon Java's OOP model with features like data classes, sealed classes, and properties.

Try It Yourself:

Kotlin

// Basic class with properties
class Person(val name: String, var age: Int) {
    // Secondary constructor
    constructor(name: String) : this(name, 0)
    
    // Method
    fun introduce() {
        println("Hello, I'm $name and I'm $age years old.")
    }
}

// Data class (automatically generates equals(), hashCode(), toString(), etc.)
data class Book(val title: String, val author: String, val year: Int)

// Inheritance
open class Animal(val name: String) {
    open fun makeSound() {
        println("$name makes a sound")
    }
}

class Dog(name: String) : Animal(name) {
    override fun makeSound() {
        println("$name barks")
    }
}

// Interface
interface Drawable {
    fun draw()
}

class Circle : Drawable {
    override fun draw() {
        println("Drawing a circle")
    }
}

// Companion object (similar to static in Java)
class MathUtils {
    companion object {
        fun square(x: Int): Int = x * x
        const val PI = 3.14159
    }
}

fun main() {
    // Using basic class
    val person = Person("Alice", 25)
    person.introduce()
    person.age = 26  // Can modify var property
    // person.name = "Bob"  // Error: val property is read-only
    
    // Using data class
    val book = Book("Kotlin in Action", "Dmitry Jemerov", 2017)
    println(book)  // Automatically uses toString()
    
    val book2 = book.copy(year = 2020)  // Copy with modification
    println(book2)
    
    // Using inheritance
    val animal = Animal("Generic Animal")
    animal.makeSound()
    
    val dog = Dog("Rex")
    dog.makeSound()
    
    // Using interface
    val circle = Circle()
    circle.draw()
    
    // Using companion object
    println("Square of 4 is ${MathUtils.square(4)}")
    println("Value of PI is ${MathUtils.PI}")
    
    // Object expression (anonymous object)
    val anonymousObject = object : Drawable {
        override fun draw() {
            println("Drawing anonymously")
        }
    }
    anonymousObject.draw()
}

Code Output

Key Points:

Classes are declared with the class keyword
Primary constructor is part of the class header
val properties are read-only, var properties are mutable
Data classes automatically implement useful methods
Inheritance uses : symbol (e.g., class Child : Parent())
Methods are open for overriding by default in Kotlin (unlike Java)
Interfaces define contracts that classes can implement
Companion objects provide static-like functionality
Object expressions create anonymous objects on the fly
Kotlin has null safety built into the type system

Premium Content

COLLECTIONS & LAMBDAS

Learn to work with collections and functional programming concepts

Intermediate

Module 6: Collections and Functional Programming

Kotlin provides a rich set of collection types and powerful functional programming capabilities. Collections can be mutable or immutable, and lambda expressions enable concise and expressive code for processing data.

Try It Yourself:

Kotlin

fun main() {
    // Lists (immutable by default)
    val fruits = listOf("Apple", "Banana", "Orange", "Mango")
    println("Fruits: $fruits")
    println("First fruit: ${fruits[0]}")
    println("Fruits size: ${fruits.size}")
    
    // Mutable list
    val mutableFruits = mutableListOf("Apple", "Banana")
    mutableFruits.add("Orange")
    mutableFruits.remove("Banana")
    println("Mutable fruits: $mutableFruits")
    
    // Sets (unique elements)
    val uniqueNumbers = setOf(1, 2, 3, 2, 1)
    println("Unique numbers: $uniqueNumbers")
    
    // Maps (key-value pairs)
    val ages = mapOf("Alice" to 25, "Bob" to 30, "Charlie" to 35)
    println("Ages: $ages")
    println("Alice's age: ${ages["Alice"]}")
    
    // Functional operations on collections
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    // Filter even numbers
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println("Even numbers: $evenNumbers")
    
    // Map (transform each element)
    val squaredNumbers = numbers.map { it * it }
    println("Squared numbers: $squaredNumbers")
    
    // Reduce (combine all elements)
    val sum = numbers.reduce { acc, num -> acc + num }
    println("Sum of numbers: $sum")
    
    // Find first element matching condition
    val firstEven = numbers.find { it % 2 == 0 }
    println("First even number: $firstEven")
    
    // Group by condition
    val grouped = numbers.groupBy { if (it % 2 == 0) "even" else "odd" }
    println("Grouped numbers: $grouped")
    
    // Sorting
    val unsorted = listOf(5, 2, 8, 1, 9)
    val sorted = unsorted.sorted()
    println("Sorted: $sorted")
    
    // Chaining operations
    val result = numbers
        .filter { it > 5 }
        .map { it * 2 }
        .take(3)
    println("Filtered, mapped, and taken: $result")
    
    // Lambda expressions
    val add: (Int, Int) -> Int = { a, b -> a + b }
    println("5 + 3 = ${add(5, 3)}")
    
    // Higher-order function with lambda
    fun processNumbers(numbers: List<Int>, operation: (Int) -> Int): List<Int> {
        return numbers.map(operation)
    }
    
    val doubled = processNumbers(listOf(1, 2, 3)) { it * 2 }
    println("Doubled numbers: $doubled")
    
    // Collection builders
    val builtList = buildList {
        add("First")
        addAll(listOf("Second", "Third"))
        if (size > 1) {
            removeAt(0)
        }
    }
    println("Built list: $builtList")
}

Code Output

Key Points:

Kotlin distinguishes between mutable and immutable collections
listOf() creates immutable lists, mutableListOf() creates mutable ones
Sets store unique elements and don't preserve order
Maps store key-value pairs for efficient lookups
Functional operations like filter, map, reduce process collections
Lambda expressions { parameters -> body } enable concise code
The it keyword refers to the single parameter in a lambda
Operations can be chained for complex data transformations
Higher-order functions take functions as parameters
Collection builders provide a DSL for creating collections

PRACTICE PLAYGROUND

Experiment with what you've learned

Your Coding Playground: Try Your Own Kotlin Code

Use this space to experiment with everything you've learned. Try combining different Kotlin concepts and see the results in real-time! This is your sandbox to practice and explore.

Kotlin

// Your Kotlin code here
fun main() {
    println("Welcome to the Kotlin Playground!")
    println("Try writing your own Kotlin code below:")
    
    // Example: Simple calculator function
    fun calculate(a: Int, b: Int, operation: String): Int {
        return when (operation) {
            "add" -> a + b
            "subtract" -> a - b
            "multiply" -> a * b
            "divide" -> if (b != 0) a / b else 0
            else -> throw IllegalArgumentException("Unknown operation: $operation")
        }
    }
    
    // Test the calculator
    println("5 + 3 = ${calculate(5, 3, "add")}")
    println("10 - 4 = ${calculate(10, 4, "subtract")}")
    
    // Example: Working with collections
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    val evenSquares = numbers
        .filter { it % 2 == 0 }
        .map { it * it }
    
    println("Even numbers squared: $evenSquares")
    
    // Example: Simple class
    data class Person(val name: String, val age: Int) {
        fun isAdult() = age >= 18
    }
    
    val people = listOf(
        Person("Alice", 25),
        Person("Bob", 17),
        Person("Charlie", 30)
    )
    
    val adults = people.filter { it.isAdult() }
    println("Adults: $adults")
    
    // Try adding your own code below!
}

Code Output

Challenge Exercises:

Create a function that:
- Takes a list of numbers and returns their sum
- Filters out negative numbers
- Uses a lambda expression
Build a simple class hierarchy with:
- A base class Shape with an area() function
- Subclasses Circle and Rectangle
- Override the area() function in each subclass
Create a program that:
- Reads user input
- Processes it with collection operations
- Outputs meaningful results
Implement a simple calculator that:
- Supports basic operations (+, -, *, /)
- Uses a when expression
- Handles division by zero gracefully
Combine all concepts into a complete mini-application

Tips & Resources:

Use the Kotlin standard library functions for common operations
Experiment with different collection types (List, Set, Map)
Try using extension functions to add functionality to existing classes
Practice error handling with try-catch blocks
Explore Kotlin's null safety features
For more practice, try solving coding challenges on platforms like LeetCode or HackerRank

KOTLIN BASICS

Learn the fundamental structure of Kotlin programs

Module 1: Kotlin Program Structure

Try It Yourself:

Key Points:

VARIABLES & DATA TYPES

Learn to work with variables and different data types

Module 2: Variables and Data Types

Try It Yourself:

Key Points:

CONTROL FLOW

Learn to control program flow with conditionals and loops

Module 3: Control Flow Statements

Try It Yourself:

Key Points:

FUNCTIONS

Learn to create and use functions in Kotlin

Module 4: Functions in Kotlin

Try It Yourself:

Key Points:

OOP IN KOTLIN

Learn Object-Oriented Programming concepts in Kotlin

Module 5: Object-Oriented Programming

Try It Yourself:

Key Points:

COLLECTIONS & LAMBDAS

Learn to work with collections and functional programming concepts

Module 6: Collections and Functional Programming

Try It Yourself:

Key Points:

PRACTICE PLAYGROUND

Experiment with what you've learned

Your Coding Playground: Try Your Own Kotlin Code

Challenge Exercises:

Tips & Resources:

Unlock Premium SkillMynte Content

Premium Courses

Certification

Mentorship

Monthly

Annual Best Value

Lifetime